/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package games.freecell.control;

import commomgame.Deck;
import commomgame.Director;
import games.freecell.structure.RegionOfCells;
import games.patience.core.RegionOfFoundations;
import games.freecell.structure.RegionOfReservesFreeCell;

/**
 *
 * @author João Carlos Nunes Bittencourt
 * @author Ian Andersson
 */
public class FreeCellGame {

    private Deck deck = new Deck();
    private RegionOfFoundations regionOfFoundations = new RegionOfFoundations(4);
    private RegionOfReservesFreeCell regionOfReserves = new RegionOfReservesFreeCell(8);
    private RegionOfCells regionOfCells = new RegionOfCells(4);

    public FreeCellGame() {
        deck.shuffle();
    }

    public RegionOfCells getRegionOfCells() {
        return regionOfCells;
    }

    public void setRegionOfCells(RegionOfCells regionOfCells) {
        this.regionOfCells = regionOfCells;
    }

    /**
     * Método que retorna a instancia da região de Fundações do jogo
     * @return objeto de RegionOfFoundations
     */
    public RegionOfFoundations getRegionOfFoundations() {
        return regionOfFoundations;
    }

    /**
     *Método que define a região de Fundações  do jogo
     * @param regionOfFoundations objeto de RegionOfFoundations
     */
    public void setRegionOfFoundations(RegionOfFoundations regionOfFoundations) {
        this.regionOfFoundations = regionOfFoundations;
    }

    /**
     *Método que retorna a instancia da região de Reservas do jogo
     * @return objeto de RegionOfReservesFreeCell
     */
    public RegionOfReservesFreeCell getRegionOfReserves() {
        return regionOfReserves;
    }

    /**
     *Método que define a região de Reservas  do jogo
     * @param regionOfReserves objeto de RegionOfReservesFreeCell
     */
    public void setRegionOfReserves(RegionOfReservesFreeCell regionOfReserves) {
        this.regionOfReserves = regionOfReserves;
    }

    /**
     *Método que distribui as cartas para as regiões, assim como, definindo a situação inicial das mesmas nas
     * suas respectivas subregiões, ou seja, definindo quais cartas estarão visíveis no inicio do jogo.
     */
    public void shareCardsToRegion() {
        regionOfReserves.sendCardsToRegion2(52, this.deck.getListOfCards());
    }

    /**
     *Método responsável por mapear a movimentação realizada e chamar as regras que definirão se a carta pode ser movida ou não
     * @param value inteiro que representa o valor da carta a ser movida
     * @param origin string que representa o nome da região de origem da carta
     * @param target string que representa o nome da região de destino da carta
     * @param nipe string que representa o nipe da carta a ser movida
     */
    public boolean moveCard(int value, String origin, String target, String nipe) {

        //mapeia Strings em Regions
        if (origin.charAt(0) == 'R') {
            if (target.charAt(0) == 'F') {
                return Director.invokeRuleReservesFoundations(value, nipe, origin, target, regionOfReserves, regionOfFoundations);
            }
        }

        if (origin.charAt(0) == 'R') {
            if (target.charAt(0) == 'R') {
                return FreeCellDirector.invokeRuleReserveReserve(value, nipe, origin, target, regionOfReserves, regionOfReserves, regionOfCells);
            }
        }

        if (origin.charAt(0) == 'R') {
            if (target.charAt(0) == 'C') {
                return FreeCellDirector.invokeRuleReserveCells(value, nipe, origin, target, regionOfReserves, regionOfCells);
            }
        }

        if (origin.charAt(0) == 'C') {
            if (target.charAt(0) == 'F') {
                return FreeCellDirector.invokeRuleCellsFoundations(value, nipe, origin, target, regionOfCells, regionOfFoundations);
            }
        }

        if (origin.charAt(0) == 'C') {
            if (target.charAt(0) == 'R') {
                return FreeCellDirector.invokeRuleCellsReserve(value, nipe, origin, target, regionOfCells, regionOfReserves);
            }
        }

        if (origin.charAt(0) == 'F') {
            if (target.charAt(0) == 'R') {
                return Director.invokeRuleFoundationsReserves(value, nipe, origin, target, regionOfFoundations, regionOfReserves);
            }
        }
        return false;

    }
}
